package com.guodi.model.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.guodi.common.utils.CommonUtil;
import com.guodi.core.tool.utils.Func;
import com.guodi.model.entity.IdtIndicatorsType;
import com.guodi.model.mapper.IdtIndicatorsTypeMapper;
import com.guodi.model.service.IIdtIndicatorsTypeService;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @描述：指标分类表 服务类
 * @作者: 彭辉
 * @日期: 2020-06-05
 */
@Service
public class IdtIndicatorsTypeServiceImpl extends ServiceImpl<IdtIndicatorsTypeMapper, IdtIndicatorsType> implements IIdtIndicatorsTypeService {

    @Resource
    private IdtIndicatorsTypeMapper idtIndicatorsTypeMapper;

    @Resource
    private IdtIndicatorsTypeServiceImpl idtIndicatorsTypeService;

    /**
     * 顶层节点的parent_id值
     */
    private static final String TOP_PARENT_ID = "-1";

    @Override
    public Integer selectMaxSort() {
        return idtIndicatorsTypeMapper.selectMaxSort();
    }

    @Override
    public void deleteByParentId(String parentId) {
        idtIndicatorsTypeMapper.deleteByParentId(parentId);
    }

    @Override
    public IdtIndicatorsType findByCode(String code, String year, String divisionCode) {
        // 处理逻辑，如果某年某行政区划未配置数据，则返回全域中最新的数据
        List<IdtIndicatorsType> idtIndicatorsTypeList = idtIndicatorsTypeMapper.findByCode(code, year, divisionCode);
        // 由于行政区划包含上下级关系，通过代码匹配
        for (IdtIndicatorsType idtIndicatorsType:idtIndicatorsTypeList) {
            List<String> divisionCodes = Func.toStrList(idtIndicatorsType.getDivisionCode());
            if(divisionCodes.contains(divisionCode)){
                return idtIndicatorsType;
            }
        }
        // 检索该体系下其他年份或者行政区下是否有数据，如果则返回最新年数据
        LambdaQueryWrapper<IdtIndicatorsType> lambda = new QueryWrapper().lambda();
        lambda.eq(IdtIndicatorsType::getCode, code);
        IdtIndicatorsType one = idtIndicatorsTypeService.getOne(lambda);
        LambdaQueryWrapper<IdtIndicatorsType> queryWrapper = new QueryWrapper().lambda();
        queryWrapper.eq(IdtIndicatorsType::getParentId, one.getId());
        List<IdtIndicatorsType> idtIndicatorsTypes = idtIndicatorsTypeService.list(queryWrapper);
        if(idtIndicatorsTypes.size() > 0){
            // 返回最新年的体系数据
            String years = idtIndicatorsTypes.stream().map(x -> x.getYear()).collect(Collectors.joining(","));
            // 去重并且排序
            List<String> yearList = Func.toStrList(years).stream().distinct().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
            // 最新年数据
            String newYear = yearList.get(0);
            // 检索匹配返回指定的体系
            List<IdtIndicatorsType> indicatorsTypes = idtIndicatorsTypes.stream().filter(x -> x.getYear().indexOf(newYear) != -1).collect(Collectors.toList());
            // 产品要求根据创建时间排序，返回最新创建的
            indicatorsTypes.stream().sorted(Comparator.comparing(IdtIndicatorsType::getCreateTime).reversed());
            return indicatorsTypes.get(0);
        }else {
            return null;
        }
    }

    @Override
    public IdtIndicatorsType accurateGet(String code, String year, String divisionCode) {
        if(StringUtils.isEmpty(code) || StringUtils.isEmpty(year) || StringUtils.isEmpty(divisionCode)){
            return null;
        }

        // 模糊查询
        List<IdtIndicatorsType> idtIndicatorsTypes = idtIndicatorsTypeMapper.findByCode(code, year, divisionCode);
        if(CollectionUtils.isEmpty(idtIndicatorsTypes)){
            return null;
        }

        // 内存精确筛选
        for (IdtIndicatorsType idtIndicatorsType : idtIndicatorsTypes) {
            List<String> divisionCodes = Func.toStrList(idtIndicatorsType.getDivisionCode());
            List<String> years = Func.toStrList(idtIndicatorsType.getYear());
            if(years.contains(year)){
                // 为了兼容gis运维区划编码和基础运维区划编码位数不一致问题 todo: 只到六位
                if(divisionCodes.contains(divisionCode)
                    || divisionCodes.contains(CommonUtil.fill2SixCode(divisionCode))
                    || divisionCodes.contains(CommonUtil.toCurrentLevelAreaCode(divisionCode))){
                    return idtIndicatorsType;
                }

            }
        }
        return null;
    }

    @Override
    public List<IdtIndicatorsType> listByType(String idtType) {
        return idtIndicatorsTypeMapper.listByType(idtType);
    }

    /**
     * 根据指标id或者指标编码、年份、行政区划，返回这个指标所在的指标体系。
     * @入参： idtCode 指标编码（idtCode 和 idtId必须有一个存在，如果都存在，则以idtId 为准，idtCode 是指标的自增编码）
     * @入参： idtId 指标id（idtCode 和 idtId必须有一个存在，如果都存在，则以idtId 为准）
     * @入参： year 年份
     * @入参： divisionCode 行政区划
     * @出参： 如果没有对应的指标体系，返回空列表，而不是null
     * @作者： 陈宏成
     * @日期： 2021/10/9
     */
    @Override
    public List<IdtIndicatorsType> findTypeForIdt(String idtCode, String idtId, int year , String divisionCode){
        if (!StringUtils.hasText(idtCode) && !StringUtils.hasText(idtId)){
            throw new RuntimeException("idtCode 和 idtId 不能都为空");
        }
        return this.idtIndicatorsTypeMapper.findTypeForIdt(idtCode,  idtId,  String.valueOf(year) ,  divisionCode);
    }

    /**
     * 检查名字是否存在，比较的是一个体系下的，如果属于不同体系，那就不算重名
     * @param idtType 体系编码
     * @param name 名称
     * @param id 记录id，如果不为空，则会比较重名的是不是自己；如果为空，则跳过
     * @return true -- 存在重名，false -- 不存在重名
     */
    @Override
    public boolean checkNameExistInType(String idtType, String name, String id){
        List<IdtIndicatorsType> idtIndicatorsTypes = this.listByType(idtType);
        long count = idtIndicatorsTypes.stream().filter(type -> {
            return Objects.equals(type.getName(), name);
        }).filter(type -> {
            if (StringUtils.hasText(id)) {
                return !Objects.equals(type.getId(), id);
            }
            return true;
        }).count();
        return count > 0;
    }

    /**
     * 检查名字是否存在，比较的是指标体系的名字，也就是比较最外层的名字
     * @param name 名称
     * @param id 记录id，如果不为空，则会比较重名的是不是自己；如果为空，则跳过
     * @return true -- 存在重名，false -- 不存在重名
     */
    @Override
    public boolean checkNameExistForType( String name, String id){
        LambdaQueryWrapper<IdtIndicatorsType> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNotNull(IdtIndicatorsType::getCode);
        queryWrapper.eq(IdtIndicatorsType::getParentId, TOP_PARENT_ID);
        queryWrapper.eq(IdtIndicatorsType::getName, name);
        queryWrapper.ne(StringUtils.hasText(id), IdtIndicatorsType::getId, id);

        int count = this.count(queryWrapper);
        return count > 0 ;
    }
}
